import java.util.*;

public class Solution {

    //
    public static void main1(String[] args){
        Scanner in = new Scanner(System.in);
        char[] s = in.next().toCharArray();

        int ret = (int) 1e9;
        for(char ch = 'a'; ch <= 'z'; ch++){
            int sum = 0;
            for(int i = 0; i < s.length; i++){
                sum += Math.min(Math.abs(s[i] - ch), 26 - Math.abs(s[i] - ch));
            }
            ret = Math.min(ret, sum);
        }
        System.out.println(ret);
    }

    //
    public ArrayList<Integer> findOrder (int numProject, ArrayList<ArrayList<Integer>> groups) {
        List<List<Integer>> edges = new ArrayList<>();
        for(int i = 0; i < numProject; i++){
            edges.add(new ArrayList<>());
        }
        int[] in = new int[numProject];

        for(int i = 0; i < groups.size(); i++){
            int a = groups.get(i).get(0), b = groups.get(i).get(1);
            edges.get(b).add(a);
            in[a]++;
        }

        Queue<Integer> queue = new LinkedList<>();
        for(int i = 0; i < numProject; i++){
            if(in[i] == 0){
                queue.add(i);
            }
        }

        ArrayList<Integer> ret = new ArrayList<>();
        while(!queue.isEmpty()){
            int a = queue.poll();
            ret.add(a);
            for(int b : edges.get(a)){
                if(--in[b] == 0){
                    queue.add(b);
                }
            }
        }

        if(ret.size() == numProject){
            return ret;
        }else{
            return new ArrayList<>();
        }
    }

    //
    public static void main3(String[] args) {
        Scanner in = new Scanner(System.in);
        int n = in.nextInt();
        int[] arr = new int[n + 1];
        for(int i = 1; i <= n; i++){
            arr[i] = in.nextInt();
        }

        int[] f = new int[n + 1];
        int[] g = new int[n + 1];
        for(int i = 1; i <= n; i++){
            f[i] = 1;
            for(int j = 1; j < i; j++){
                if(arr[j] < arr[i]){
                    f[i] = Math.max(f[i], f[j] + 1);
                }
            }
        }
        for(int i = n; i >= 1; i--){
            g[i] = 1;
            for(int j = n; j > i; j--){
                if(arr[j] < arr[i]){
                    g[i] = Math.max(g[i], g[j] + 1);
                }
            }
        }

        int ret = 0;
        for(int i = 1; i <= n; i++){
            ret = Math.max(ret, f[i] + g[i] - 1);
        }
        System.out.println(n - ret);
    }

    //
//    public ListNode insertGreatestCommonDivisors(ListNode head) {
//        ListNode node = head;
//
//        while(node.next != null){
//            node.next = new ListNode(gcd(node.val, node.next.val), node.next);
//            node = node.next.next;
//        }
//        return head;
//    }
    public int gcd(int a, int b){
        while(a != 0){
            int t = a;
            a = b % a;
            b = t;
        }
        return b;
    }

    //
//    public Node insert(Node head, int insertVal) {
//        Node node = new Node(insertVal);
//        if(head == null){
//            node.next = node;
//            return node;
//        }
//        if(head.next == null){
//            head.next = node;
//            node.next = head;
//            return head;
//        }
//
//        Node cur = head, next = head.next;
//        while(next != head){
//            if(cur.val <= insertVal && next.val >= insertVal){
//                break;
//            }
//            if(cur.val > next.val){
//                if(insertVal > cur.val || insertVal < next.val){
//                    break;
//                }
//            }
//            cur = cur.next;
//            next = next.next;
//        }
//        cur.next = node;
//        node.next = next;
//        return head;
//    }

    //
    int[] dx = {0,0,1,-1};
    int[] dy = {1,-1,0,0};

    public int[][] flipChess (int[][] A, int[][] f) {

        for(int[] i : f){
            int a = i[0] - 1, b = i[1] - 1;
            for(int k = 0; k < 4; k++){
                int x = a + dx[k], y = b + dy[k];
                if(x >= 0 && x < 4 && y >= 0 && y < 4){
                    A[x][y] ^= 1;
                }
            }
        }
        return A;
    }

    //
    public static void main4(String[] args){
        Scanner in = new Scanner(System.in);
        int n = in.nextInt();
        long[] arr = new long[n + 1];
        for(int i = 1; i <= n; i++){
            arr[i] = in.nextLong();
        }

        long[] dp = new long[n + 1];
        for(int i = 3; i <= n; i++){
            dp[i] = Math.max(dp[i - 3] + arr[i - 1], dp[i - 1]);
        }
        System.out.println(dp[n]);
    }

    //
    public static int n;
    public static int[] arr = new int[2010];

    public static int bfs(){
        int left = 1, right = 1, ret = 0;
        while(left <= right){
            ret++;
            int r = right;
            for(int i = left; i <= right; i++){
                r = Math.max(r, arr[i] + i);
                if(r >= n) { return ret;}
            }
            left = right + 1;
            right = r;
        }
        return -1;
    }

    public static void main5(String[] args){
        Scanner in = new Scanner(System.in);
        n = in.nextInt();
        for(int i = 1; i <= n; i++){
            arr[i] = in.nextInt();
        }

        System.out.println(bfs());
    }

    //
//    public ListNode reverseList(ListNode head) {
//        if(head == null || head.next == null) { return head;}
//
//        ListNode newHead = reverseList(head.next);
//        head.next.next = head;
//        head.next = null;
//
//        return newHead;
//    }

    //
//    public ListNode reverseBetween(ListNode head, int left, int right) {
//        ListNode dummy = new ListNode(0, head);
//        ListNode node = dummy;
//        for(int i = 0; i < left - 1; i++){
//            node = node.next;
//        }
//
//        ListNode prev = null;
//        ListNode cur = node.next;
//        for(int i = 0; i < right - left + 1; i++){
//            ListNode next = cur.next;
//            cur.next = prev;
//            prev = cur;
//            cur = next;
//        }
//
//        node.next.next = cur;
//        node.next = prev;
//        return dummy.next;
//    }

    //
}
